home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / bbsutil / hsrc_117.zip / ENTRY.C < prev    next >
Text File  |  1990-11-09  |  12KB  |  595 lines
  1. /* entry.c */
  2.  
  3. #include <stdio.h>
  4. #include <ctype.h>
  5. #include <stdlib.h>
  6. #include <alloc.h>
  7. #include <mem.h>
  8. #include <string.h>
  9. #include <conio.h>
  10. #include <dos.h>
  11. #include "twindow.h"
  12. #include "keys.h"
  13.  
  14. #define FIELDCHAR '_'
  15. int insert_mode=FALSE;
  16. extern int helpkey;
  17. extern unsigned char usemouse;
  18.  
  19. /* Local prototypes */
  20. extern void pascal print_clock(void);
  21. void pascal addfield(WINDOW *wnd,FIELD *fld);
  22. void pascal data_value(WINDOW *wnd,FIELD *fld);
  23. void pascal insert_status(void);
  24. int pascal read_field(WINDOW *wnd,FIELD *fld);
  25. void pascal right_justify(char *s);
  26. void pascal right_justify_zero_fill(char *s);
  27. int pascal validate_date(char *s);
  28. int pascal endstroke(int c);
  29. int pascal spaces(char *c);
  30.  
  31. /* Initialize a template */
  32. void pascal init_template(WINDOW *wnd) {
  33.  
  34.     FIELD *fld,*fl;
  35.  
  36.     fld=FHEAD;
  37.     while (fld) {
  38.         fl=fld->fnxt;
  39.         free(fld);
  40.         fld=fl;
  41.     }
  42.     FHEAD=NULL;
  43. }
  44.  
  45. /* Establish a field in a template */
  46. FIELD * pascal establish_field(wnd,cl,rw,msk,bf,ty)
  47. WINDOW *wnd;
  48. int rw;
  49. int cl;
  50. char *msk;
  51. char *bf;
  52. int ty;
  53. {
  54.     FIELD *fld;
  55.  
  56.     if ((fld=malloc(sizeof(FIELD)))==NULL)
  57.         return NULL;
  58.     fld->fmask=msk;
  59.     fld->frow=rw;
  60.     fld->fcol=cl;
  61.     fld->fbuff=bf;
  62.     fld->ftype=ty;
  63.     fld->fprot=0;
  64.     fld->fnxt=fld->fprv=NULL;
  65.     fld->fvalid=NULL;
  66.     fld->fhelp=NULL;
  67.     fld->fhwin=NULL;
  68.     fld->flx=fld->fly=0;
  69.     addfield(wnd,fld);
  70.     return fld;
  71. }
  72.  
  73. /* Add a field to the end of the list */
  74. static void pascal addfield(WINDOW *wnd,FIELD *fld) {
  75.  
  76.     if (FTAIL) {
  77.         fld->fprv=FTAIL;
  78.         FTAIL->fnxt=fld;
  79.     }
  80.     FTAIL=fld;
  81.     if(!FHEAD)
  82.         FHEAD=fld;
  83. }
  84.  
  85. /* Display a data field */
  86. static void pascal disp_field(WINDOW *wnd,char *bf,char *msk) {
  87.  
  88.     while (*msk) {
  89.         wputcharaw (wnd,*msk !=FIELDCHAR ? *msk : *bf++);
  90.         msk++;
  91.     }
  92. }
  93.  
  94. /* Display the data value in a field */
  95. static void pascal data_value(WINDOW *wnd,FIELD *fld) {
  96.  
  97.     wcursor(wnd,fld->fcol,fld->frow);
  98.     disp_field(wnd,fld->fbuff,fld->fmask);
  99. }
  100.  
  101. /* Display all the fields in a window */
  102. void pascal field_tally(WINDOW *wnd)
  103. {
  104.     FIELD *fld;
  105.  
  106.     fld=FHEAD;
  107.     while(fld != NULL) {
  108.         data_value(wnd,fld);
  109.         fld=fld->fnxt;
  110.     }
  111. }
  112.  
  113. /* Set a field's help window */
  114. void pascal field_window(FIELD *fld,char *hwin,int x,int y) {
  115.  
  116.     fld->fhwin=hwin;
  117.     fld->flx=x;
  118.     fld->fly=y;
  119. }
  120.  
  121. /* Clear a template to all blanks */
  122. void pascal clear_template (WINDOW *wnd) {
  123.  
  124.     FIELD *fld;
  125.     char *bf,*msk;
  126.  
  127.     fld=FHEAD;
  128.     while (fld != NULL) {
  129.         bf=fld->fbuff;
  130.         msk=fld->fmask;
  131.         while (*msk) {
  132.             if(*msk==FIELDCHAR)
  133.                 *bf++=' ';
  134.             msk++;
  135.         }
  136.         fld=fld->fnxt;
  137.     }
  138.     field_tally(wnd);
  139. }
  140.  
  141. /* Prepare a template to end in blanks */
  142. void pascal prep_template (WINDOW *wnd) {
  143.  
  144.     FIELD *fld;
  145.     char *bf,*msk;
  146.  
  147.     fld=FHEAD;
  148.     while (fld != NULL) {
  149.         bf=fld->fbuff;
  150.         msk=fld->fmask;
  151.         while((*bf!=0) && (*msk!=0)) {
  152.             if (*msk!=FIELDCHAR) {
  153.                 msk++;
  154.                 continue;
  155.             }
  156.             if (*msk==0) {
  157.                 break;
  158.             }
  159.             bf++;
  160.             msk++;
  161.         }
  162.         while (*msk) {
  163.             if(*msk==FIELDCHAR)
  164.                 *bf++=' ';
  165.             msk++;
  166.         }
  167.         *bf=0;
  168.         fld=fld->fnxt;
  169.     }
  170.     field_tally(wnd);
  171. }
  172.  
  173. /* Set insert/exchange cursor shape */
  174. static void pascal insert_status() {
  175.     set_cursor_type(insert_mode ? 0x0106 : 0x0607);
  176. }
  177.  
  178. /* Read a field from the keyboard */
  179. static int pascal read_field (WINDOW *wnd,FIELD *fld) {
  180.  
  181.     char *mask=fld->fmask,*buff=fld->fbuff;
  182.     int done=FALSE,c,column;
  183.  
  184.     column=fld->fcol;
  185.     while(*mask!=FIELDCHAR) {
  186.         column++;
  187.         mask++;
  188.     }
  189.     while (TRUE) {
  190.         wcursor(wnd,column,fld->frow);
  191.         c=0;
  192.         SHOWMOUSE;
  193.         CONFINEMOUSE(wnd);
  194.         while(!kbhit()) {
  195.           if(usemouse) {
  196.  
  197.                 union REGS rg;
  198.  
  199.                 rg.x.ax=3;
  200.                 int86(0x33,&rg,&rg);
  201.                 move_mouse(rg.x.cx/8,rg.x.dx/8);
  202.                 rg.x.ax=5;
  203.                 rg.x.bx=0;          /* Check left button */
  204.                 int86(0x33,&rg,&rg);
  205.                 if(rg.x.bx) {       /* Button pressed */
  206.                     rg.x.cx/=8;     /* Mouse x */
  207.                     rg.x.dx/=8;     /* Mouse y */
  208.                     if(rg.x.cx==COL && rg.x.dx==ROW) {
  209.                         c=ESC;
  210.                         break;
  211.                     }
  212.                     if(rg.x.dx==ROW && rg.x.cx==COL+WIDTH-1) {
  213.                         c=PGUP;
  214.                         break;
  215.                     }
  216.                     if(rg.x.cx==COL && rg.x.dx==ROW+HEIGHT-1) {
  217.                         c=PGDN;
  218.                         break;
  219.                     }
  220.                     if(rg.x.cx==COL+WIDTH-1 & rg.x.dx==ROW+HEIGHT-1) {
  221.                         c=F10;
  222.                         break;
  223.                     }
  224.                     if(!c) {
  225.                         c=get_screen_char(rg.x.cx,rg.x.dx);
  226.                         if((c=='-' || c=='X') && toupper(fld->ftype)=='O') {
  227.                             if(c=='-') c='X';
  228.                             else c='-';
  229.                         }
  230.                     }
  231.                     if(!isdigit(c) && (toupper(fld->ftype)!='O' && toupper(fld->ftype)!='A')) c=0;
  232.                     if(c) break;
  233.                 }
  234.                 rg.x.ax=3;
  235.                 int86(0x33,&rg,&rg);
  236.                 move_mouse(rg.x.cx/8,rg.x.dx/8);
  237.                 rg.x.ax=5;
  238.                 rg.x.bx=1;
  239.                 int86(0x33,&rg,&rg);
  240.                 if(rg.x.bx) {
  241.                     c=ESC;
  242.                     break;
  243.                 }
  244.                 rg.x.ax=3;
  245.                 int86(0x33,&rg,&rg);
  246.                 move_mouse(rg.x.cx/8,rg.x.dx/8);
  247.                 rg.x.ax=5;
  248.                 rg.x.bx=2;
  249.                 int86(0x33,&rg,&rg);
  250.                 if(rg.x.bx) {
  251.                     c=DN;
  252.                     break;
  253.                 }
  254.           }
  255. #ifdef USECLOCK
  256.           print_clock();
  257. #endif
  258.         }
  259.         HIDEMOUSE;
  260.         if(!c)c=get_char();
  261.         if(fld->ftype=='A' || fld->ftype=='O') c=toupper(c);
  262.         clear_message();
  263.         switch(c) {
  264.             case '\b':
  265.             case BS:
  266.                 if(buff==fld->fbuff) {
  267.                     done=c==BS;
  268.                     break;
  269.                 }
  270.                 --buff;
  271.                 do {
  272.                     --mask;
  273.                     --column;
  274.                 } while (*mask !=FIELDCHAR);
  275.                 if (c==BS) break;
  276.             case DEL:
  277.                 if(fld->ftype!='O') {
  278.                     movmem(buff+1,buff,strlen(buff));
  279.                     *(buff+strlen(buff))=' ';
  280.                     wcursor(wnd,column,fld->frow);
  281.                     disp_field(wnd,buff,mask);
  282.                 }
  283.                 break;
  284.             case CTRL_Y:
  285.                 strset(buff,' ');
  286.                 disp_field(wnd,buff,mask);
  287.                 break;
  288.             case CTRL_RIGHT:
  289.                 do {
  290.                     column++;
  291.                     mask++;
  292.                     if(*mask==FIELDCHAR)buff++;
  293.                 } while(*buff==' ' && *mask);
  294.                 if(*mask) {
  295.                     do {
  296.                         column++;
  297.                         mask++;
  298.                         if(*mask==FIELDCHAR)buff++;
  299.                     }    while(*buff!=' ' && *mask);
  300.                 }
  301.                 break;
  302.             case CTRL_LEFT:
  303.                 if(mask>fld->fmask) {
  304.                     do {
  305.                         --column;
  306.                         --mask;
  307.                         if(*mask==FIELDCHAR)--buff;
  308.                     } while(*buff==' ' && mask>fld->fmask);
  309.                 }
  310.                 if(mask>fld->fmask) {
  311.                     do {
  312.                         --column;
  313.                         --mask;
  314.                         if(*mask==FIELDCHAR)--buff;
  315.                     } while(*buff!=' ' && mask>fld->fmask);
  316.                 }
  317.                 break;
  318.             case END:
  319.                 column=fld->fcol;
  320.                 mask=fld->fmask;
  321.                 buff=fld->fbuff;
  322.                 do {
  323.                     column++;
  324.                     mask++;
  325.                     if(*mask==FIELDCHAR)buff++;
  326.                 } while(*mask);
  327.                 while(*buff==' ' && mask>fld->fmask) {
  328.                     --column;
  329.                     --mask;
  330.                     if(*mask==FIELDCHAR)--buff;
  331.                 }
  332.                 if(*buff!=' ') buff++;
  333.                 break;
  334.             case HOME:
  335.                 column=fld->fcol;
  336.                 mask=fld->fmask;
  337.                 buff=fld->fbuff;
  338.                 while(*mask!=FIELDCHAR) {
  339.                     column++;
  340.                     mask++;
  341.                 }
  342.                 break;
  343.             case FWD:
  344.                 do {
  345.                     column++;
  346.                     mask++;
  347.                 } while(*mask && *mask!=FIELDCHAR);
  348.                 buff++;
  349.                 break;
  350.             case INS:
  351.                 insert_mode ^= TRUE;
  352.                 insert_status();
  353.                 break;
  354.             case '.':
  355.                 if (fld->ftype=='C') {
  356.                     if (*mask++ && *buff==' ') {
  357.                         *buff++='0';
  358.                         if (*mask++ && *buff==' ')
  359.                             *buff++='0';
  360.                     }
  361.                     right_justify(fld->fbuff);
  362.                     wcursor(wnd,fld->fcol,fld->frow);
  363.                     disp_field(wnd,fld->fbuff,fld->fmask);
  364.                     column=fld->fcol+strlen(fld->fmask)-2;
  365.                     mask=fld->fmask+strlen(fld->fmask)-2;
  366.                     buff=fld->fbuff+strlen(fld->fbuff)-2;
  367.                     break;
  368.                 }
  369.             default:
  370.                 if (endstroke(c)) {
  371.                     done=TRUE;
  372.                     break;
  373.                 }
  374.                 if (toupper(fld->ftype)!='A'&&toupper(fld->ftype)!='O'&&!isdigit(c)) {
  375.                     error_message("Numbers only");
  376.                     break;
  377.                 }
  378.                 if (toupper(fld->ftype)=='O'&& c!='X') c='-';
  379.                 if (insert_mode && fld->ftype!='O') {
  380.                     movmem(buff,buff+1,strlen(buff)-1);
  381.                     disp_field(wnd,buff,mask);
  382.                     wcursor(wnd,column,fld->frow);
  383.                 }
  384.                 *buff++=c;
  385.                 wputcharaw(wnd,c);
  386.                 do {
  387.                     column++;
  388.                     mask++;
  389.                 } while(*mask && *mask!=FIELDCHAR);
  390.                 if(!*mask)
  391.                     c=FWD;
  392.                 break;
  393.             }
  394.             i